System.Span<T-Struktur>

Der Span<T> Typ ist eine Referenzstruktur , die auf dem Stapel zugewiesen wird, anstatt auf dem verwalteten Heap. Verweistypen weisen eine Reihe von Einschränkungen auf, um sicherzustellen, dass sie nicht zum verwalteten Heap heraufgestuft werden können, einschließlich, dass sie nicht boxen können, sie können variablen vom Typ Objectdynamic oder einem beliebigen Schnittstellentyp nicht zugewiesen werden, sie können keine Felder in einem Verweistyp sein, und sie können nicht über Grenzen hinweg awaityield verwendet werden. Aufrufe an zwei Methoden, Equals(Object) und GetHashCode, werfen ein NotSupportedException.

Verwenden Sie System.ReadOnlySpan<T>für Spannen, die unveränderliche oder schreibgeschützte Strukturen darstellen.

Arbeitsspeicher

A Span<T> stellt einen zusammenhängenden Bereich des beliebigen Speichers dar. Eine Span<T> Instanz wird häufig verwendet, um die Elemente eines Arrays oder eines Teils eines Arrays zu enthalten. Im Gegensatz zu einem Array kann eine Span<T> Instanz jedoch auf verwalteten Speicher, systemeigenen Speicher oder auf den im Stapel verwalteten Speicher verweisen. Im folgenden Beispiel wird ein Span<Byte> aus einem Array erzeugt:

// Create a span over an array.
byte[] array = new byte[100];
Span<byte> arraySpan = new(array);

byte data = 0;
for (int ctr = 0; ctr < arraySpan.Length; ctr++)
    arraySpan[ctr] = data++;

int arraySum = 0;
foreach (byte value in array)
    arraySum += value;

Console.WriteLine($"The sum is {arraySum}");

// Output:  The sum is 4950

// Create a span over an array.
let array = Array.zeroCreate<byte> 100
let arraySpan = Span<byte> array

let mutable data = 0uy
for i = 0 to arraySpan.Length - 1 do
    arraySpan[i] <- data
    data <- data + 1uy

let mutable arraySum = 0
for value in array do
    arraySum <- arraySum + int value

printfn $"The sum is {arraySum}"
// Output:  The sum is 4950

Im folgenden Beispiel wird ein Span<Byte> aus 100 Bytes nativem Speicher erstellt.

// Create a span from native memory.
nint native = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe
{
    nativeSpan = new Span<byte>(native.ToPointer(), 100);
}
byte data = 0;
for (int ctr = 0; ctr < nativeSpan.Length; ctr++)
    nativeSpan[ctr] = data++;

int nativeSum = 0;
foreach (byte value in nativeSpan)
    nativeSum += value;

Console.WriteLine($"The sum is {nativeSum}");
Marshal.FreeHGlobal(native);

// Output:  The sum is 4950

// Create a span from native memory.
let native = Marshal.AllocHGlobal 100
let nativeSpan = Span<byte>(native.ToPointer(), 100)

let mutable data = 0uy
for i = 0 to nativeSpan.Length - 1 do
    nativeSpan[i] <- data
    data <- data + 1uy

let mutable nativeSum = 0
for value in nativeSpan do
    nativeSum <- nativeSum + int value

printfn $"The sum is {nativeSum}"
Marshal.FreeHGlobal native
// Output:  The sum is 4950

Im folgenden Beispiel wird das Schlüsselwort "C# stackalloc " verwendet, um 100 Bytes Arbeitsspeicher auf dem Stapel zuzuweisen:

// Create a span on the stack.
byte data = 0;
Span<byte> stackSpan = stackalloc byte[100];
for (int ctr = 0; ctr < stackSpan.Length; ctr++)
    stackSpan[ctr] = data++;

int stackSum = 0;
foreach (byte value in stackSpan)
    stackSum += value;

Console.WriteLine($"The sum is {stackSum}");

// Output:  The sum is 4950

    // Create a span on the stack.
    let mutable data = 0uy
    let stackSpan = 
        let p = NativeInterop.NativePtr.stackalloc<byte> 100 |> NativeInterop.NativePtr.toVoidPtr
        Span<byte>(p, 100)

    for i = 0 to stackSpan.Length - 1 do
        stackSpan[i] <- data
        data <- data + 1uy

    let mutable stackSum = 0
    for value in stackSpan do
        stackSum <- stackSum + int value

    printfn $"The sum is {stackSum}"
// Output:  The sum is 4950

Da Span<T> eine Abstraktion über einen beliebigen Speicherblock ist, arbeiten Methoden des Span<T>-Typs und Methoden mit Span<T>-Parametern mit jedem Span<T>-Objekt, unabhängig von der Art des Speichers, den es kapselt. Beispielsweise können alle separaten Codeabschnitte, die die Spanne initialisieren und die Summe der Elemente berechnen, in einzelne Initialisierungs- und Berechnungsmethoden umgestaltet werden, wie im folgenden Beispiel veranschaulicht wird:

public static void WorkWithSpans()
{
    // Create a span over an array.
    byte[] array = new byte[100];
    Span<byte> arraySpan = new(array);

    InitializeSpan(arraySpan);
    Console.WriteLine($"The sum is {ComputeSum(arraySpan):N0}");

    // Create an array from native memory.
    var native = Marshal.AllocHGlobal(100);
    Span<byte> nativeSpan;
    unsafe
    {
        nativeSpan = new Span<byte>(native.ToPointer(), 100);
    }

    InitializeSpan(nativeSpan);
    Console.WriteLine($"The sum is {ComputeSum(nativeSpan):N0}");

    Marshal.FreeHGlobal(native);

    // Create a span on the stack.
    Span<byte> stackSpan = stackalloc byte[100];

    InitializeSpan(stackSpan);
    Console.WriteLine($"The sum is {ComputeSum(stackSpan):N0}");
}

public static void InitializeSpan(Span<byte> span)
{
    byte value = 0;
    for (int ctr = 0; ctr < span.Length; ctr++)
        span[ctr] = value++;
}

public static int ComputeSum(ReadOnlySpan<byte> span)
{
    int sum = 0;
    foreach (byte value in span)
        sum += value;

    return sum;
}

// The example displays the following output:
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

open System
open System.Runtime.InteropServices
open FSharp.NativeInterop

// Package FSharp.NativeInterop.NativePtr.stackalloc for reuse.
let inline stackalloc<'a when 'a: unmanaged> length : Span<'a> =
    let voidPointer = NativePtr.stackalloc<'a> length |> NativePtr.toVoidPtr
    Span<'a>(voidPointer, length)

let initializeSpan (span: Span<byte>) =
    let mutable value = 0uy
    for i = 0 to span.Length - 1 do
        span[i] <- value
        value <- value + 1uy

let computeSum (span: Span<byte>) =
    let mutable sum = 0
    for value in span do
        sum <- sum + int value
    sum

let workWithSpans () =
    // Create a span over an array.
    let array = Array.zeroCreate<byte> 100
    let arraySpan = Span<byte> array

    initializeSpan arraySpan
    printfn $"The sum is {computeSum arraySpan:N0}"

    // Create an array from native memory.
    let native = Marshal.AllocHGlobal 100
    let nativeSpan = Span<byte>(native.ToPointer(), 100)

    initializeSpan nativeSpan
    printfn $"The sum is {computeSum nativeSpan:N0}"

    Marshal.FreeHGlobal native

    // Create a span on the stack.
    let stackSpan = stackalloc 100

    initializeSpan stackSpan
    printfn $"The sum is {computeSum stackSpan:N0}"

// The example displays the following output:
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

Felder

Wenn es ein Array umbricht, kann Span<T> ein gesamtes Array umschließen, wie in den Beispielen im Abschnitt Speicher gezeigt. Weil Slicing unterstützt wird, kann Span<T> auch auf jeden zusammenhängenden Bereich innerhalb des Arrays verweisen.

Im folgenden Beispiel wird ein Segment der mittleren fünf Elemente eines ganzzahligen Arrays mit 10 Elementen erstellt. Beachten Sie, dass der Code die Werte jeder ganzen Zahl im Segment verdoppelt. Wie die Ausgabe zeigt, spiegeln sich die von der Spanne vorgenommenen Änderungen in den Werten des Arrays wider.

using System;

var array = new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
var slice = new Span<int>(array, 2, 5);
for (int ctr = 0; ctr < slice.Length; ctr++)
    slice[ctr] *= 2;

// Examine the original array values.
foreach (var value in array)
    Console.Write($"{value}  ");
Console.WriteLine();

// The example displays the following output:
//      2  4  12  16  20  24  28  16  18  20

module Program

open System

[<EntryPoint>]
let main _ =
    let array = [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
    let slice = Span<int>(array, 2, 5)
    for i = 0 to slice.Length - 1 do
        slice[i] <- slice[i] * 2

    // Examine the original array values.
    for value in array do
        printf $"{value}  "
    printfn ""
    0
// The example displays the following output:
//      2  4  12  16  20  24  28  16  18  20

Scheiben

Span<T> enthält zwei Überladungen der Slice Methode, die einen Datenschnitt aus der aktuellen Spanne bilden, die bei einem angegebenen Index beginnt. Dadurch können die Daten in einer Span<T> als eine Menge von logischen Abschnitten behandelt werden, die nach Bedarf von Teilen einer Datenverarbeitungspipeline mit minimaler Leistungsbeeinträchtigung verarbeitet werden können. Da beispielsweise moderne Serverprotokolle häufig textbasiert sind, ist die Manipulation von Zeichenfolgen und Teilzeichenfolgen besonders wichtig. In der String Klasse ist Substringdie Hauptmethode zum Extrahieren von Teilzeichenfolgen . Für Datenpipelines, die auf umfangreiche Zeichenfolgenmanipulation angewiesen sind, bringt ihre Verwendung einige Leistungseinbußen mit sich, da sie:

1. Erstellt eine neue Zeichenfolge, die die Teilzeichenfolge enthält.
2. Kopiert eine Teilmenge der Zeichen aus der ursprünglichen Zeichenfolge in die neue Zeichenfolge.

Dieser Zuordnungs- und Kopiervorgang kann eliminiert werden, indem entweder Span<T> oder ReadOnlySpan<T> verwendet wird, wie im folgenden Beispiel gezeigt:

using System;

class Program2
{
    static void Run()
    {
        string contentLength = "Content-Length: 132";
        var length = GetContentLength(contentLength.ToCharArray());
        Console.WriteLine($"Content length: {length}");
    }

    private static int GetContentLength(ReadOnlySpan<char> span)
    {
        var slice = span.Slice(16);
        return int.Parse(slice);
    }
}
// Output:
//      Content length: 132

module Program2

open System

let getContentLength (span: ReadOnlySpan<char>) =
    let slice = span.Slice 16
    Int32.Parse slice

let contentLength = "Content-Length: 132"
let length = getContentLength (contentLength.ToCharArray())
printfn $"Content length: {length}"
// Output:
//      Content length: 132